.TITLE	DRMAP
	.IDENT	/05.08/
;
; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; MODIFIED FOR RSX-11M-PLUS VERSION 2 BY:
;
;	B. S. MCCARTHY
;	J. M. LAWLER
;
; MODIFIED FOR RSX-11M-PLUS VERSION 2.1 BY:
;
;	J. R. KAUFFMAN
;
; MODIFIED FOR RSX-11M-PLUS VERSION 3.0 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.0 BY
;	J. W. BERZLE
;	J. R. KAUFFMAN
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.1 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.2 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.4 BY:
;
;	D. CARROLL	23-JUL-1992	05.08
;
;		DC136 -- FIX OPTIMIZATION WHICH CAUSED WINDOW LENGTH OF 4K*n+1
;			 TO LOAD BAD VALUES INTO THE LAST PDR.
;
	.PAGE
;
; **-CSM DISPATCHER-DISPATCH CSM ENTRY
; 
; THIS MODULE IS MAPPED AT SUPERVISOR MODE VIRTUAL ZERO ON DETECTING
; THE PRESENCE OF THE FIRST SUPERVISOR MODE WINDOW IN A CONTEXT SWITCH.
; THIS ALLOWS TASKS TO HAVE SUPER MODE LIBRARIES AT ARBITRARY STARTING
; ADDRESSES, DESPITE THE OPERATION OF CSM.
;
;		* * *   N O T E   W E L L   * * *
;
; THIS CODE MUST BE AT VIRTUAL 0 IN SUPERVISOR MODE. SINCE WE JUST MAP
; THIS COMMON AS 32WORDS RO IN SYSXT, THIS CODE MUST BE AT THE BEGINNING
; OF THIS COMMON.
;
; THE ENTRY VECTOR TO SUPERVISOR MODE IS AS FOLLOWS:
;
;	MOV	#COMPLETION-ROUTINE,-(SP)
;	CSM	#ROUTINE
;
; NOTE: IMMEDIATE MODE EMULATION OF THE CSM INSTRUCTION IS REQUIRED
; 	IN THE EXECUTIVE.
;
; THE CSM INSTRUCTION TRANSFERS CONTROL TO THE ADDRESS CONTAINED IN
; SUPERVISOR MODE VIRTUAL 10.  AT THIS POINT THE STACK IS THE FOLLOWING:
;
;	  (SP)	ROUTINE ADDRESS
;	 2(SP)	PC (PAST END OF TRANSFER VECTOR)
;	 4(SP)	PS WITH CONDITION CODES CLEARED
;	 6(SP)	COMPLETION-ROUTINE ADDRESS
;	10(SP)	RETURN ADDRESS
;
; A ROUTINE ADDRESS OF 0 IS SPECIAL CASED TO SUPPORT RETURN TO
; SUPERVISOR MODE FROM A USER MODE DEBUGGING AID (ODT).  IN THIS CASE
; STACK IS THE FOLLOWING:
;
;	  (SP)	ZERO
;	 2(SP)	PC FROM CSM TO BE DISCARDED
;	 4(SP)	PS FROM CSM TO BE DISCARDED
;	 6(SP)	SUPER MODE PC SUPPLIED BY DEBUGGER
;	10(SP)	SUPER MODE PS SUPPLIED BY DEBUGGER
;

	.IF DF S$$LIB

	.ENABL	LSB

; BASE ADDRESS USED FOR RELATIVE ADDRESSES WITHIN MODULE

BASE:

; DEBUGGER RETURN TO SUPER MODE ENTRY. MUST START AT VIRTUAL ZERO

	CMP	(SP)+,(SP)+	;CLEAN OFF PS AND PC FROM CSM

;
; THIS ENTRY POINT PERFORMS THE NECESSARY STACK MANAGEMENT TO ALLOW
; AN RTI FROM SUPER MODE TO EITHER SUPER MODE OR USER MODE.
; THE IS AS REQUIRED FOR AN RTI:
;
;	 (SP)	SUPER MODE PC
;	2(SP)	SUPER MODE PS

	TST	2(SP)		;RETURNING TO USER MODE?
	BR	70$		;JOIN COMMON CODE

; CSM TRANSFER ADDRESS, THIS WORD MUST BE AT VIRTUAL 10 IN SUPER MODE

	.WORD	CSMSVR-BASE	;CSM DISPATCHER ENTRY

; DISPATCH CSM ENTRY

CSMSVR:	MOV	6(SP),2(SP)	;SET COMPLETION ROUTINE ADDRESS FOR RETURN
	JMP	@(SP)+		;TRANSFER TO SUPER MODE LIBRARY ROUTINE

; EXIT DISPATCHER FOR ODT AND $SRTI:

70$:	BPL	80$		;IF PL YES
	MOV	#6,-(SP)	;NUMBER OF BYTES FOR (SP), PS, AND PC
	ADD	SP,(SP)		;COMPUTE CLEAN STACK VALUE
	MTPI	SP		;SET UP PREVIOUS STACK POINTER
80$:	RTT			;RETURN TO PREVIOUS MODE AND CALLER

	.DSABL	LSB

	.ENDC ; DF S$$LIB
	.PAGE
;
; THE FOLLOWING DIRECTIVES RECEIVE AS INPUT POINTERS TO A WINDOW DEFINITION
; BLOCK, WHICH SERVES AS A COMMUNICATION AREA BETWEEN THE ISSUING TASK AND
; THE EXECUTIVE. THE FORMAT OF THE WINDOW DEFINITION BLOCK IS:
;
;		-------------------------------------------------
;	W.NID	!			!			!
;	W.NAPR	!	BASE APR	!	WINDOW ID	!
;		!			!			!
;		!-----------------------------------------------!
;		!						!
;	W.NBAS	!	VIRTUAL BASE ADDRESS (BYTES)		!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NSIZ	!	WINDOW SIZE (32W BLOCKS)		!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NRID	!	REGION ID				!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NOFF	!	OFFSET IN PARTITION (32W BLOCKS)	!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NLEN	!	LENGTH TO MAP (32W BLOCKS)		!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NSTS	!	STATUS WORD				!
;		!						!
;		!-----------------------------------------------!
;		!						!
;	W.NSRB	!	SEND/RECEIVE BUFFER ADDR (BYTES)	!
;		!						!
;		-------------------------------------------------
;
; MACRO LIBRARY CALLS
;


	.IF DF	P$$LAS

	.MCALL	HDRDF$,PCBDF$,TCBDF$,WDBDF$
	HDRDF$			;DEFINE HEADER AND WINDOW BLOCK OFFSETS
	PCBDF$			;DEFINE PCB AND ATTACHMENT DESCR OFFSETS
	TCBDF$			;DEFINE TCB OFFSETS
	WDBDF$			;DEFINE WINDOW DEFINITION BLOCK OFFSETS
	.PAGE
;+
; **-$DRCRW-CREATE ADDRESS WINDOW
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO ALLOCATE AN ADDRESS WINDOW IN THE
; HEADER OF THE ISSUING TASK, UNMAPPING AND ELIMINATING ANY OVERLAPPING
; ADDRESS WINDOWS OF THE SAME TYPE, AND OPTIONALLY TO MAP THE NEW
; WINDOW.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(117.),DPB SIZE(2.)
;	WD. 01 -- ADDRESS OF WINDOW DEFINITION BLOCK
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE WINDOW DEFINITION BLOCK.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
;	INPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NAPR=BASE APR OF REGION.
;		W.NSIZ=DESIRED SIZE OF ADDRESS WINDOW.
;		W.NRID=ID OF REGION TO MAP OR 0 FOR TASK REGION (IF WS.MAP=1).
;		W.NOFF=OFFSET WITHIN REGION TO MAP (IF WS.MAP=1).
;		W.NLEN=LENGTH TO MAP OR 0 TO DEFAULT TO SMALLER OF WINDOW SIZE
;			OR SIZE LEFT IN PARTITION (IF WS.MAP=1).
;		W.NSTS=CONTROL INFORMATION.
;			WS.SIS=1 IF WINDOW IS TO BE IN SUPER I SPACE.
;			WS.MAP=1 IF MAPPING IS TO OCCUR.
;			WS.WRT=1 IF MAPPING IS TO OCCUR WITH WRITE ACCESS.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS RETURNED TO TASK)
;
;	C=0 IF DIRECTIVE IS SUCCESSFULLY COMPLETED.
;		DIRECTIVE STATUS OF +1 IS RETURNED.
;	C=1 IF DIRECTIVE IS REJECTED.
;		DIRECTIVE STATUS OF 'D.RS6' IS RETURNED IF THE THE
;			DIRECTIVE FAILS IN THE MAPPING STAGE BECAUSE
;			THE SPECIFIED REGION HAS INCURRED A PARITY
;			ERROR.
;		DIRECTIVE STATUS OF 'D.RS16' IS RETURNED IF THE SPECIFIED
;			ACCESS IS DENIED IN THE MAPPING STAGE.
;		DIRECTIVE STATUS OF 'D.RS84' IS RETURNED IF AN INVALID APR-
;			WINDOW SIZE COMBINATION IS SPECIFIED OR IF AN
;			INVALID REGION OFFSET-LENGTH COMBINATION IS SPECIFIED
;			IN THE MAPPING STAGE.
;		DIRECTIVE STATUS OF 'D.RS85' IS RETURNED IF THERE ARE NO
;			AVAILABLE WINDOW BLOCKS.
;		DIRECTIVE STATUS OF 'D.RS86' IS RETURNED IF AN INVALID REGION
;			ID IS SPECIFIED IN THE MAPPING STAGE.
;
;	OUTPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NID=ASSIGNED WINDOW ID.
;		W.NBAS=VIRTUAL BASE ADDRESS OF WINDOW.
;		W.NLEN=LENGTH ACTUALLY MAPPED.
;		W.NSTS=INDICATION OF ANY CHANGES IN MAPPING STATUS.
;			WS.CRW=1 IF ADDRESS WINDOW SUCCESSFULLY ESTABLISHED.
;			WS.ELW=1 IF ANY ADDRESS WINDOWS WERE ELIMINATED.
;			WS.UNM=1 IF ANY ADDRESS WINDOWS WERE UNMAPPED.
;
;	NOTE:	ON SYSTEMS SUPPORTING EXTERNAL TASK HEADERS, THE 
;		DIRECTIVE DISPATCHER COPIES THE USER WDB INTO AN
;		INTERMEDIATE BUFFER AREA.  ON EXIT, THE DIRECTIVE
;		DISPATCHER WILL WRITE ANY OUTPUT FIELDS TO THE
;		USER BUFFER.  
;
;-

$DRCRW::MOV	R4,-(SP)	;SAVE ADDRESS OF TASK HEADER
	MOV	H.WND(R4),R4	;POINT TO NUMBER OF WINDOW BLOCKS
	MOV	(R4)+,R1	;PICK UP NUMBER OF WINDOW BLOCKS

	.IF DF	U$$DAS

	MOV	R1,-(SP)	;SAVE NUMBER OF WINDOW BLOCKS

	.ENDC	; DF U$$DAS

	MOV	(R3)+,R2	;PICK UP APR NUMBER IN HIGH BYTE (W.NID)
	CLRB	R2		;CLEAR OUT LOW BYTE
	CMP	R2,#7*256.	;LEGAL APR NUMBER?
	BLOS	3$		; IF LOS YES
	JMP	40$		;
3$:
	ASR	R2		;CONVERT TO BASE ADDRESS IN 32W BLOCKS
	MOV	R2,(R3)		;STORE VIRTUAL BASE ADDRESS (W.NBAS)
	ASR	(R3)		;CONVERT TO BYTES (W.NBAS)
	ASR	(R3)		;
	SWAB	(R3)+		;
	MOV	R2,-(SP)	;CALCULATE HIGH ADDRESS
	ADD	(R3),(SP)	;(W.NSIZ)
	BCS	40$		;IF CS ILLEGAL SIZE
	CMP	(SP),#2000	;LEGAL TOP ADDRESS?
	BHI	40$		;IF HI NO
	MOV	R1,-(SP)	;SAVE NUMBER OF WINDOWS

	.IF DF	U$$DAS

	BIT	#T4.DSP,T.ST4(R5) ;TASK USE USER DATA SPACE ?
	BEQ	5$		;IF EQ NO, ONLY WINDOW ZERO
				;CAN'T BE OVERLAPPED
	DEC	(SP)		;YES IT DOES, WINDOWS ZERO
				;AND ONE ARE OFF LIMITS

	.ENDC	; DF U$$DAS

5$:	CMP	-(R3),-(R3)	;POINT TO START OF WINDOW
				;BLOCK (W.NBAS) (W.NID)
	MOV	#WS.EDS,R0	;GET NECESSARY BITS FOR SELECTION
	BIC	W.NSTS(R3),R0	;ALL BITS SET IN W.NSTS ?
	BNE	10$		;IF NE NO, LEAVE ALONE

	.IF DF U$$DAS

	BIC	#WS.SIS,W.NSTS(R3) ;ALWAYS CLEAR SUPER I SINCE IT
				   ;WAS JUST A FLAG BIT.
	BIT	#T4.DSP,T.ST4(R5) ;TASK BUILT WITH SEPARATE I/D SPACE ?
	BNE	10$		;IF NE YES, LEAVE WINDOW IN D SPACE
	BIC	#WS.UDS,W.NSTS(R3) ;CLEAR USER DATA SPACE FOR I ONLY TASK

	.IFF	; DF U$$DAS

	BIC	#WS.EDS,W.NSTS(R3) ;ALWAYS LOOKS LIKE IT DEFAULTED TO
				   ;I SPACE ON NON I/D SYSTEMS

	.ENDC	; DF U$$DAS

10$:	TST	W.BSIZ(R4)	;POINTING TO AN ESTABLISHED ADDRESS WINDOW?
	BEQ	20$		;IF EQ NO
 
 
	.IF DF	S$$LIB
 
	BIT	#WS.SIS,W.NSTS(R3) ;CREATING SUPERVISOR I SPACE WINDOW?
	BEQ	14$		;IF EQ NO
	TSTB	W.BFPD(R4)	;LOOKING AT SUPERVISOR I SPACE WINDOW?
	BMI	30$		;IF MI NO
	BR	15$		;

	.IFTF	; DF S$$LIB

14$:				;REFERENCE LABEL

	.IF DF	U$$DAS

	BIT	#WS.UDS,W.NSTS(R3) ;CREATING USER D SPACE WINDOW ?
	BEQ	141$		;IF EQ NO
	BIT	#20,W.BFPD(R4)	;LOOKING AT USER D SPACE WINDOW ?
	BEQ	30$		;IF EQ NO
	BR	15$		;YES
141$:				;REFERENCE LABEL

	.ENDC	; DF U$$DAS

	.IFT	; DF S$$LIB

	.IF DF U$$DAS

	CMPB	#216,W.BFPD(R4)	;LOOKING AT USER I SPACE WINDOW ?
	BLT	30$		;IF LT NO

	.IFF	; DF U$$DAS

	TSTB	W.BFPD(R4)	;LOOKING AT SUPER I SPACE WINDOW ?
	BPL	30$		;IF PL YES

	.ENDC	; DF U$$DAS

 
	.IFTF
 
15$:	MOV	W.BLVR(R4),R0	;PICK UP LOW VIRTUAL ADDRESS
	SWAB	R0		;CONVERT TO 32W BLOCKS
	ASL	R0		;
	ASL	R0		;
	CMP	2(SP),R0	;POSSIBLE VIRTUAL ADDRESS OVERLAP?
	BLOS	30$		;IF LOS NO
	ADD	W.BSIZ(R4),R0	;CALCULATE HIGH ADDRESS
	CMP	R2,R0		;VIRTUAL ADDRESS OVERLAP?
	BHIS	30$		;IF HIS NO

	.IF DF	U$$DAS

	TST	(SP)		;ALREADY ESTABLISHED WINDOW ?
	BEQ	17$		;IF EQ YES, ALLOW UNMAP

	.IFTF	; DF U$$DAS

	CMP	R1,(SP)		;OVERLAPPING WINDOW ZERO (OR ONE
				;IF I/D TASK ?)

	.IFT	; DF U$$DAS

	BHIS	40$		;IF HIS YES, DON'T ALLOW UNMAP

	.IFF	; DF U$$DAS

	BEQ	40$		;IF EQ YES, DON'T ALLOW UNMAP

	.ENDC	; DF U$$DAS

17$:				;REFERENCE LABEL
	CALL	ELAW		;ELIMINATE ADDRESS WINDOW
20$:	TST	(SP)		;HAS A WINDOW BEEN ESTABLISHED?
	BEQ	30$		;IF EQ YES
	CMP	(R3)+,(R3)+	;POINT TO WINDOW SIZE IN BLOCK (W.NID)(W.NBAS)
	MOV	(R3),W.BSIZ(R4)	;STORE SIZE, ESTABLISHING WINDOW (W.NSIZ)
	MOV	-(R3),W.BLVR(R4) ;SET LOW VIRTUAL ADDRESS (W.NBAS)
	MOVB	-(R3),R0	;PICK UP FIRST APR NUMBER (W.NAPR)
	ASL	R0		;CONVERT APR NUMBER TO WORD OFFSET
 
	.IFT
 
	BIT	#WS.SIS,W.NSTS-W.NAPR(R3) ;CREATING SUPERVISOR WINDOW?
	BNE	25$		;IF NE YES
 
	.ENDC
 

	.IF DF U$$DAS

	BIT	#WS.UDS,W.NSTS-W.NAPR(R3) ;CREATING D SPACE WINDOW ?
	BEQ	23$		;IF EQ NO
	ADD	#UDSDR0,R0	;POINT TO FIRST D SPACE PDR
	BR	25$		;ENTER COMMON CODE

	.ENDC	; DF U$$DAS

23$:	ADD	#UINDR0,R0	;POINT TO FIRST I SPACE PDR
25$:	MOVB	R0,W.BFPD(R4)	;SET FIRST PDR ADDRESS

	.IF DF M$$PRO!C$$CBP

	CLR	W.BLPD(R4)	;INITIALIZE CACHE BITS IN LAST PDR
	BIT	#WS.NBP,W.NSTS-W.NAPR(R3) ;OK TO BYPASS CACHE ?
	BEQ	27$		;IF EQ YES, LEAVE CACHE BITS ALONE
	BIS	#WB.NBP,W.BLPD(R4) ;REMEMEBER NOT TO BYPASS THE CACHE
27$:				;REFERENCE LABEL

	.ENDC	; DF M$$PRO!C$$CBP

	.IF DF U$$DAS

	MOVB	4(SP),-(R3)	;PICK UP TOTAL NUMBER OF WINDOWS
				;(W.NID)

	.IFF	; DF U$$DAS

	MOVB	(SP),-(R3)	;PICK UP TOTAL NUMBER OF WINDOWS
				;(W.NID)

	.ENDC	; DF U$$DAS

	SUB	R1,(R3)		;SET ADDRESS WINDOW ID (W.NID)
	CLR	(SP)		;INDICATE WINDOW HAS BEEN ESTABLISHED
30$:	ADD	#W.BLGH,R4	;POINT TO NEXT WINDOW BLOCK
	DEC	R1		;MORE WINDOW BLOCKS?
	BGT	10$		;IF GT YES
	TST	(SP)+		;WAS AN ADDRESS WINDOW ESTABLISHED?
	BNE	50$		;IF NE NO

	.IF DF U$$DAS

	CMP	(SP)+,(SP)+	;POP CALCULATED HIGH ADDRESS AND
				;SAVED NUMBER OF WINDOWS

	.IFF	; DF U$$DAS

	TST	(SP)+		;POP CALCULATED HIGH ADDRESS

	.ENDC	; DF U$$DAS


	MOV	(SP)+,R4	;RESTORE TASK HEADER ADDRESS
	BIS	#WS.CRW,W.NSTS(R3) ;INDICATE ADDRESS WINDOW WAS CREATED
	BIT	#WS.MAP,W.NSTS(R3) ;IS WINDOW TO BE MAPPED?
	BNE	$DRMAP		;MAP ADDRESS WINDOW AND EXIT
	RETURN			;
40$:	DRSTS	D.RS84		;ALIGNMENT ERROR
50$:	DRSTS	D.RS85		;NO AVAILABLE WINDOWS
	.PAGE
;+
; **-$DRELW-ELIMINATE ADDRESS WINDOW
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO ELIMINATE THE SPECIFIED ADDRESS
; WINDOW, UNMAPPING IT FIRST IF NECESSARY.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(119.),DPB SIZE(2.)
;	WD. 01 -- ADDRESS OF WINDOW DEFINITION BLOCK
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE WINDOW DEFINITION BLOCK.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
;	INPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NID=ID OF ADDRESS WINDOW TO ELIMINATE.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS RETURNED TO TASK)
;
;	C=0 IF DIRECTIVE IS SUCCESSFULLY COMPLETED.
;		DIRECTIVE STATUS OF +1 IS RETURNED.
;	C=1 IF DIRECTIVE IS REJECTED.
;		DIRECTIVE STATUS OF 'D.RS87' IS RETURNED IF AN INVALID
;			ADDRESS WINDOW WAS SPECIFIED.
;
;	OUTPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NSTS=INDICATION OF ANY CHANGES IN MAPPING STATUS.
;			WS.ELW=1 IF ADDRESS WINDOW SUCCESSFULLY ELIMINATED.
;			WS.UNM=1 IF THE ADDRESS WINDOW WAS UNMAPPED.
;-

$DRELW::CALL	$SRWND		;SEARCH FOR AND VERIFY SPECIFIED WINDOW
ELAW:	CALL	$UNMAP		;UNMAP IF NECESSARY
	BCC	10$		;IF CC UNMAPPING WAS NOT PERFORMED
	BIS	#WS.UNM,W.NSTS(R3) ;INDICATE A WINDOW WAS UNMAPPED
10$:	CLR	W.BSIZ(R4)	;INDICATE ADDRESS WINDOW IS ELIMINATED
	BIS	#WS.ELW,W.NSTS(R3) ;INDICATE ADDRESS WINDOW ELIMINATED
	RETURN			;
	.PAGE
;+
; **-$DRMAP-MAP WINDOW TO REGION
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO MAP THE SPECIFIED ADDRESS
; WINDOW TO AN OFFSET IN THE SPECIFIED REGION, UNMAPPING IF NECESSARY.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(121.),DPB SIZE(2.)
;	WD. 01 -- ADDRESS OF WINDOW DEFINITION BLOCK
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE WINDOW DEFINITION BLOCK.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
;	INPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NID=ID OF WINDOW TO MAP.
;		W.NRID=ID OF REGION TO MAP TO OR 0 TO DEFAULT TO TASK REGION.
;		W.NOFF=OFFSET WITHIN REGION TO MAP TO.
;		W.NLEN=LENGTH TO MAP OR 0 TO DEFAULT TO SMALLER OF WINDOW
;			SIZE OR SIZE LEFT IN PARTITION.
;		W.NSTS=CONTROL INFORMATION.
;			WS.WRT=1 IF WRITE ACCESS IS DESIRED.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS RETURNED TO TASK)
;
;	C=0 IF DIRECTIVE IS SUCCESSFULLY COMPLETED.
;		DIRECTIVE STATUS OF +1 IS RETURNED.
;	C=1 IF DIRECTIVE IS REJECTED.
;		DIRECTIVE STATUS OF 'D.RS6' IS RETURNED IF THE DESIRED
;			REGION HAS INCURRED A PARITY ERROR.
;		DIRECTIVE STATUS OF 'D.RS16' IS RETURNED IF THE DESIRED
;			ACCESS TO THE REGION IS DENIED.
;		DIRECTIVE STATUS OF 'D.RS84' IS RETURNED IF AN INVALID
;			REGION OFFSET-SIZE COMBINATION IS SPECIFIED.
;		DIRECTIVE STATUS OF 'D.RS86' IS RETURNED IF AN INVALID
;			REGION ID IS SPECIFIED.
;		DIRECTIVE STATUS OF 'D.RS87' IS RETURNED IF AN INVALID
;			ADDRESS WINDOW ID IS SPECIFIED.
;
;	OUTPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NLEN=LENGTH ACTUALLY MAPPED.
;		W.NSTS=INDICATION OF ANY CHANGES IN MAPPING STATUS.
;			WS.UNM=1 IF THE WINDOW WAS UNMAPPED FIRST.
;
; THIS DIRECTIVE FIRST BUILDS AN IMAGE OF A MAPPED WINDOW BLOCK ON THE
; STACK.  THEN IF NO ERRORS ARE ENCOUNTERED, THE CORRESPONDING WINDOW IS
; UNMAPPED, IF NECESSARY, AND SET UP FROM THE STACK IMAGE.
;-


$DRMAP::

; FOR EITHER USER D OR SUPER LIBRARY SYSTEMS, WE PUSH THE TWO
; MAPPING MASKS (H.DMAP,H.SMAP) ONTO THE STACK FOR USE DURING APR
; UPDATE. H.DMAP MUST BE RE-WRITTEN TO THE HEADER AFTER THE UPDATE
; SINCE IT MAY HAVE CHANGED.

	.IF DF	S$$LIB!U$$DAS

	ASSUME	H.SMAP+1,H.DMAP	;H.SMAP,H.DMAP MUST BE IN SAME WORD
	MOV	H.SMAP(R4),-(SP) ;GET SUPER/USER D MASKS ONTO STACK

	.ENDC	; DF S$$LIB!U$$DAS

	CALL	$SRWND		;SEARCH FOR AND VALIDATE ADDRESS
				;WINDOW ID
	ADD	#W.NRID,R3	;POINT TO SPECIFIED REGION ID
	CALL	$SRATT		;SEARCH FOR MATCHING ATTACHMENT DESCRIPTOR
	MOV	A.PCB(R5),R2	;POINT TO ATTACHED PCB
	CMP	$TKTCB,$FXRPT	;IS THIS THE PARITY ERROR RECOVER TASK?
	BEQ	5$		;IF EQ YES
	BIT	#PS.PER,P.STAT(R2) ;PARITY ERROR?
	BEQ	5$		;IF EQ NO
	JMP	90$		;
5$:	BIT	#WS.RES,W.NSTS-W.NRID(R3) ;MAP ONLY IF RESIDENT?
	BEQ	10$		;NO IF EQ
	BIT	#PS.CKP!PS.CKR!PS.OUT,P.STAT(R2) ;REGION IN MEMORY?
	BEQ	10$		;IF EQ YES
	JMP	100$		;
10$:	MOV	R2,-(SP)	;SET PCB ADDRESS (W.BPCB)
	MOV	W.BLVR(R4),-(SP) ;COPY LOW VIRTUAL ADDRESS (W.BLVR)
	TST	(R3)+		;POINT TO OFFSET (W.NRID)

	.IF NDF X$$HDR

	MOV	(R3)+,R0	;PICK UP SPECIFIED OFFSET (W.NOFF)

	.IFF	; NDF X$$HDR

	MOVB	P.HDLN(R2),R0	;PICK UP LENGTH OF EXTERNAL HEADER (OR 0)
	ADD	(R3)+,R0	;CALCULATE REAL OFFSET INTO PARTITION
				;(ADD IN W.NOFF)
	BCS	35$		;IF CS THE OFFSET WRAPPED AROUND. THIS
				;MAY CAUSE A MAP INTO THE EXTERNAL HDR,
				;SO IT IS TREATED ALWAYS AS AN ERROR,
				;REGARDLESS OF FINAL OFFSET.

	.ENDC	; NDF X$$HDR

	CMP	R0,P.SIZE(R2)	;WITHIN PARTITION?
	BHIS	35$		;IF HIS NO
	MOV	(R3),R1		;PICK UP LENGTH TO MAP (W.NLEN)
	BNE	20$		;IF NE ONE WAS SPECIFIED
	MOV	P.SIZE(R2),R1	;CALCULATE SIZE TO END OF PARTITION
	SUB	R0,R1		;
	CMP	R1,W.BSIZ(R4)	;SIZE TO END GREATER THAN WINDOW SIZE? (W.BSIZ)
	BLOS	20$		;IF LOS NO
	MOV	W.BSIZ(R4),R1	;DEFAULT TO WINDOW SIZE (W.BSIZ)
20$:	MOV	R1,(R3)+	;PASS BACK SIZE USED (W.NLEN)
	MOV	R1,-(SP)	;CALCULATE HIGH VIRTUAL ADDRESS (W.BHVR)
	SWAB	(SP)		;MULTIPLY BY 64
	RORB	(SP)		;
	ROR	(SP)		;
	ROR	(SP)		;
	DEC	(SP)		;POINT TO LAST ADDRESSABLE BYTE
	ADD	2(SP),(SP)	;
	MOV	R5,-(SP)	;STORE ADDR OF ATTACHMENT DESCRIPTOR (W.BATT)
	MOV	W.BSIZ(R4),-(SP) ;COPY WINDOW SIZE (W.BSIZ)
	CMP	R1,(SP)		;LEGAL SIZE? (W.BSIZ)
	BHI	35$		;IF HI NO

	.IF DF	X$$HDR

	MOV	R0,-(SP)	;COPY THE OFFSET (W.NOFF)
	CLR	R5		;SUBTRACT THE HEADER LENGTH FROM THE OFFSET
	MOVB	P.HDLN(R2),R5	;FOR CORRECT ALIGNMENT CHECK
	SUB	R5,(SP)		;SUB THE HEADER LENGTH FOR ALIGNMENT CHECK
	BIT	#7,(SP)+	;64-BYTE ALIGNMENT?

	.IFF	; DF X$$HDR

	BIT	#7,R0		;64-BYTE ALIGNMENT?

	.IFTF	; DF X$$HDR

	BEQ	30$		;IF EQ NO
	BIT	#WS.64B,(R3)	;64-BYTE ALIGNMENT BEING ALLOWED?
	BEQ	35$		;IF EQ NO

	.IFT	; DF X$$HDR

30$:	MOV	2(SP),R5	;RESTORE R5
	MOV	R0,-(SP)	;SET OFFSET IN PARTITION (W.BOFF)

	.IFF	; DF X$$HDR

30$:	MOV	R0,-(SP)	;SET OFFSET IN PARTITION (W.BOFF)

	.ENDC	; DF X$$HDR

	ADD	R1,R0		;POINT PAST LAST 32W BLOCK MAPPED TO
	CMP	R0,P.SIZE(R2)	;WITHIN PARTITION?
	BLOS	37$		;IF LOS YES
35$:	JMP	70$		;
37$:	MOV	W.BFPD(R4),-(SP) ; SAVE FIRST PDR ADDRESS (W.BFPD)
	BITB	#AS.RED!AS.WRT,A.STAT(R5) ;READ ACCESS ALLOWED?
	BEQ	38$		;IF NE NO


	.IF DF M$$PRO!C$$CBP

	MOV	W.BLPD(R4),-(SP) ;GET PREVIOUS STATE OF CACHE BITS
	BIC	#^C<WB.NBP>,(SP) ;CLEAR ALL BUT THE NO BYPASS BIT
	BIS	#77402,(SP)	;SET FOR READ ACCESS, 4K SIZE (W.BLPD)

	.IFF	; DF M$$PRO!C$$CBP

	MOV	#77402,-(SP)	;SET FOR READ ACCESS, 4K SIZE (W.BLPD)

	.ENDC	; DF M$$PRO!C$$CBP

	BIT	#WS.WRT,(R3)	;WRITE ACCESS DESIRED? (W.NSTS)
	BEQ	40$		;IF EQ NO
	BITB	#AS.WRT,A.STAT(R5) ;WRITE ACCESS ALLOWED?
	BNE	39$		;IF NE YES
38$:	JMP	80$		;
39$:				;REFERENCE LABEL

	.IF DF M$$PRO!C$$CBP

	BIS	#4,(SP)		;CHANGE ACCESS TO READ/WRITE

	.IFF 	; DF M$$PRO!C$$CBP

	MOV	#77406,(SP)	;SET FOR 4K READ/WRITE ACCESS (W.BLPD)

	.ENDC	; DF M$$PRO!C$$CBP

40$:				;REF SYMBOL
	
	
	.IF DF M$$PRO!C$$CBP
	
	BIT	#WS.BPS,(R3)	;SHOULD ACCESSES ALWAYS BYPASS THE CACHE?
	BEQ	401$		;IF EQ NO
	BIS	#WB.BPS!100000,(SP) ;SET UP TO ALWAYS BYPASS CACHE

	.IF DF M$$PRO

	BR	43$		;

	.IFTF	; DF M$$PRO

401$:

	.IFT	; DF M$$PRO

	BIT	#WB.NBP,(SP)	;NOT BYPASSING CACHE THIS WINDOW?
	BNE	43$		;IF NE YES, SKIP BYPASS TESTS
41$:	MOV	R1,-(SP)	;SAVE R1
	MOV	A.PCB(R5),R1	;GET PCB ADDRESS
	CALL	$GTMCT		;DETERMINE NUMBER OF MAPPED TASKS
	TST	R2		;IS BYPASS NECESSARY?
	BEQ	42$		;NO IF EQ
	BIS	#100000,2(SP)	;SET BYPASS BIT IN PDR
42$:	MOV	R1,R2		;RESTORE PCB ADDRESS
	MOV	(SP)+,R1	;RESTORE R1

	.ENDC	; DF M$$PRO
	
	.ENDC	; DF M$$PRO!C$$CBP
	
	
43$:	CALL	$UNMAP		;UNMAP WINDOW IF NECESSARY
	BCC	45$		;IF CC WINDOW WAS NOT MAPPED
	BIS	#WS.UNM,(R3)	;INDICATE A WINDOW WAS UNMAPPED (W.NSTS)

; SINCE THE UNMAP MAY HAVE CAUSED THE USER-D MAPPING TO CHANGE, WE MUST
; UPDATE THE COPY OF H.SMAP ON THE STACK FROM THE CHANGED VALUE IN THE
; HEADER. 
	.IF DF	S$$LIB!U$$DAS

	.IF DF	X$$HDR

	MOV	$SAHPT,R0	;GET POINTER TO TASK HEADER

	.IFF	; DF X$$HDR

	MOV	$HEADR,R0	;GET POINTER TO TASK HEADER

	.ENDC	; DF X$$HDR

	MOV	H.SMAP(R0),W.BLGH(SP) ; UPDATE THE STORED MAPPING FLAG WORD

	.ENDC	; DF S$$LIB!U$$DAS

45$:	MOVB	W.BFPD(R4),R0	;POINT TO FIRST PDR
 
 
	.IF DF	S$$LIB
 
	BMI	46$		;IF MI USER WINDOW
	ADD	#SISDR0,R0	;POINT TO FIRST SUPERVISOR PDR
	TSTB	$SUPFL		;IS THIS FIRST SUPER MODE WINDOW ?
	BNE	455$		;IF NE YES
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)	;
	CALL	$LSUP1		;MAP SUPERVISOR D SPACE
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0	;
455$:	INCB	$SUPFL		;INDICATE ADDITIONAL SUPER I WINDOW
 
	.IFTF
 
46$:	MOV	P.REL(R2),R2	;CALCULATE OFFSET FOR FIRST PDR
	ADD	4(SP),R2	;(W.BOFF)
	CLRB	3(SP)		;INIT NUMBER OF PDR'S (W.BNPD)
50$:	INCB	3(SP)		;INC NUMBER OF PDR'S (W.BNPD)
	MOV	R2,UISAR0-UISDR0(R0) ;SET UP USER APR
	MOV	(SP),(R0)+	;SET UP NEXT USER PDR
 
	.IFT
 

; FIRST CHECK FOR A SUPERVISOR WINDOW. IF IT IS SUPERVISOR, THEN WE MUST
; CHECK THE SUPERVISOR MAPPING MASK, AND POSSIBLY UPDATE THE SUPER D
; PAR/PDR.

	CMP	R0,#UINDR0+2	;USER SPACE (I OR D) WINDOW ?
	BHIS	52$		;IF HIS YES, GO DO USER SPACE TESTS
	BITB	$BTMSK-2-SISDR0-2(R0),W.BLGH(SP) ;SUPER I/D OVERMAPPED ?
	BEQ	55$		;IF EQ NO
	MOV	R2,SDSAR0-SISDR0-2(R0) ;UPDATE SUPER D PAR
	MOV	(SP),SDSDR0-SISDR0-2(R0) ;UPDATE SUPER D PDR
	BR	55$		;GO DO NEXT PAR/PDR
52$:				;REFERENCE LABEL

	.IFTF	; DF S$$LIB

; CHECK FOR USER I OR USER D WINDOW. IF A USER I WINDOW, CHECK TO SEE
; IF BOTH SPACES MUST BE UPDATED. IF NOT, UPDATE IS DONE. IF SO, CHECK
; TO SEE IF THIS APR IS USED FOR AN EXPLICIT D WINDOW. IF SO, UPDATE
; IS DONE. IF NOT UPDATE USER D PAR/PDR

	.IF DF U$$DAS

	CMP	R0,#UDSDR0+2	;USER DATA SPACE WINDOW ?
	BHIS	53$		;IF HIS YES, GO UPDATE D SPACE
	BITB	$BTMSK-UINDR0-2(R0),W.BLGH+1(SP) ;D SPACE MAPPED BY
						 ;OTHER WINDOW ?
	BNE	55$		;IF NE YES, UPDATE IS DONE
	MOV	R2,UDSAR0-UINDR0-2(R0) ;UPDATE USER D PAR
	MOV	(SP),UDSDR0-UINDR0-2(R0) ;UPDATE USER D PDR

	.ENDC	; DF U$$DAS

; WE HAVE JUST UPDATED A USER D PAR/PDR. CHECK TO SEE IF THE
; CORRESPONDING SUPER D SPACE PAR/PDR IS CURRENTLY MAPPED INTO USERD
; OR SUPER I SPACE. IF USER D, UPDATE SUPER D PAR/PDR.

	.IFT	; DF S$$LIB

	BITB	$BTMSK-2-UINDR0-2(R0),W.BLGH(SP) ;SUPER D MAPPED TO
						 ;USER D THIS APR ?
	BNE	55$		;IF NE NO, UPDATE IS DONE
	MOV	R2,SDSAR0-UINDR0-2(R0) ;UPDATE SUPER D PAR
	MOV	(SP),SDSDR0-UINDR0-2(R0) ;UPDATE SUPER D PDR

	.ENDC	; DF S$$LIB

	.IF DF U$$DAS

	BR	55$		;BRANCH AROUND D SPACE CODE

	.IFTF	; DF U$$DAS

53$:				;REFERENCE LABEL

	.IFT	; DF U$$DAS

; SET BIT IN H.DMAP PROTOTYPE INDICATING THAT THIS APR IS IN USE
; FOR AN EXPLICIT D SPACE WINDOW.

	BISB	$BTMSK-UDSDR0-2(R0),W.BLGH+1(SP) ;INDICATE USER D WINDOW
						 ;USES THIS APR

; CHECK TO SEE IF USER D AND SUPER D ARE OVERMAPPED FOR THIS APR.
; IF THEY ARE, THEN UPDATE SUPER D PAR/PDR.

	.IF DF S$$LIB

	BITB	$BTMSK-2-UDSDR0-2(R0),W.BLGH(SP) ;SUPER D/USER D OVER-
						 ;MAPPED FOR THIS APR ?
	BNE	55$		;IF NE NO, UPDATE IS DONE
	MOV	R2,SDSAR0-UDSDR0-2(R0) ;UPDATE SUPER D PAR
	MOV	(SP),SDSDR0-UDSDR0-2(R0) ;UPDATE SUPER D PDR

	.ENDC	; DF S$$LIB

	.ENDC	; DF U$$DAS

	.IF DF	S$$LIB
 
	.IFTF
 
55$:	ADD	#200,R2		;ADVANCE APR OFFSET
	SUB	#200,R1		;DONE YET?
	BGT	50$		;IF GT NO
	
	
	.IF DF M$$PRO!C$$CBP
	
	ADD	#177,R1		;CALCULATE VALUE OF LAST APR
	SWAB	R1		;PLACE IT IN THE HIGH BYTE
	BIC	#77400,(SP)	;INITIALIZE SIZE
	BIS	R1,(SP)		;SET SIZE OF LAST PDR
	MOV	(SP),-(R0)	;SET LAST PDR
	
	.IFF 	; DF M$$PRO!C$$CBP
	
	SWAB	R1		;SHIFT UNUSED SIZE TO HIGH BYTE
	CLRB	R1		;CLEAR LOW BYTE
	ADD	R1,(SP)		;CALCULATE SIZE IN LAST PDR
	ADD	R1,-(R0)	;SET LAST PDR
	
	.ENDC	; DF M$$PRO!C$$CBP
	
	
 
	.IFT
	

; FIRST CHECK FOR A SUPERVISOR WINDOW. IF IT IS SUPERVISOR, THEN WE MUST
; CHECK THE SUPERVISOR MAPPING MASK, AND POSSIBLY UPDATE THE SUPER D
; PAR/PDR.

	CMP	R0,#UINDR0	;USER SPACE (I OR D) WINDOW ?
	BHIS	56$		;IF HIS YES, GO DO USER SPACE TESTS
	BITB	$BTMSK-2-SISDR0(R0),W.BLGH(SP) ;SUPER I/D OVERMAPPED ?
	BEQ	59$		;IF EQ NO

	.IF DF M$$PRO!C$$CBP

	MOV	(SP),SDSDR0-SISDR0(R0) ;UPDATE SUPER D PDR

	.IFF 	; DF M$$PRO!C$$CBP

	ADD	R1,SDSDR0-SISDR0(R0) ;UPDATE SUPER D PDR

	.ENDC	; DF M$$PRO!C$$CBP

	BR	59$		;UPDATE IS DONE
56$:				;REFERENCE LABEL

	.IFTF	; DF S$$LIB

; CHECK FOR USER I OR USER D WINDOW. IF A USER I WINDOW, CHECK TO SEE
; IF BOTH SPACES MUST BE UPDATED. IF NOT, UPDATE IS DONE. IF SO, CHECK
; TO SEE IF THIS APR IS USED FOR AN EXPLICIT D WINDOW. IF SO, UPDATE
; IS DONE. IF NOT UPDATE USER D PAR/PDR

	.IF DF U$$DAS

	CMP	R0,#UDSDR0	;USER DATA SPACE WINDOW ?
	BHIS	57$		;IF HIS YES, GO UPDATE D SPACE
	TST	W.BLGH(SP)	;UPDATE ALL SPACES ?
	BNE	59$		;IF NE NO
	BITB	$BTMSK-UINDR0(R0),W.BLGH+1(SP) ;D SPACE MAPPED BY
						 ;OTHER WINDOW ?
	BNE	59$		;IF NE YES, UPDATE IS DONE

	.IF DF M$$PRO!C$$CBP

	MOV	(SP),UDSDR0-UINDR0(R0) ;UPDATE USER D PDR

	.IFF 	; DF M$$PRO!C$$CBP

	ADD	R1,UDSDR0-UINDR0(R0) ;UPDATE USER D PDR

	.ENDC	; DF M$$PRO!C$$CBP

	.ENDC	; DF U$$DAS

; WE HAVE JUST UPDATED A USER D PAR/PDR. CHECK TO SEE IF THE
; CORRESPONDING SUPER D SPACE PAR/PDR IS CURRENTLY MAPPED INTO USERD
; OR SUPER I SPACE. IF USER D, UPDATE SUPER D PAR/PDR.

	.IFT	; DF S$$LIB

	BITB	$BTMSK-2-UINDR0(R0),W.BLGH(SP) ;SUPER D MAPPED TO
						 ;USER D THIS APR ?
	BNE	59$		;IF NE NO, UPDATE IS DONE

	.IF DF M$$PRO!C$$CBP

	MOV	(SP),SDSDR0-UINDR0(R0) ;UPDATE SUPER D PDR

	.IFF 	; DF M$$PRO!C$$CBP

	ADD	R1,SDSDR0-UINDR0(R0) ;UPDATE SUPER D PDR

	.ENDC	; DF M$$PRO!C$$CBP

	.ENDC	; DF S$$LIB

	.IF DF U$$DAS

	BR	59$		;BRANCH AROUND D SPACE CODE

	.IFTF	; DF U$$DAS

57$:				;REFERENCE LABEL

	.IFT	; DF U$$DAS

; CHECK TO SEE IF USER D AND SUPER D ARE OVERMAPPED FOR THIS APR.
; IF THEY ARE, THEN UPDATE SUPER D PAR/PDR.

	.IF DF S$$LIB

	BITB	$BTMSK-2-UDSDR0(R0),W.BLGH(SP) ;SUPER D/USER D OVER-
						 ;MAPPED FOR THIS APR ?
	BNE	59$		;IF NE NO, UPDATE IS DONE

	.IF DF M$$PRO!C$$CBP

	MOV	(SP),SDSDR0-UDSDR0(R0) ;UPDATE SUPER D PDR

	.IFF 	; DF M$$PRO!C$$CBP

	ADD	R1,SDSDR0-UDSDR0(R0) ;UPDATE SUPER D PDR

	.ENDC	; DF M$$PRO!C$$CBP

	.ENDC	; DF S$$LIB

	.ENDC	; DF U$$DAS

 
 
59$:	MOV	R4,R3		;COPY POINTER TO WINDOW BLOCK
	ADD	#W.BLGH,R3	;POINT PAST END OF WINDOW BLOCK
60$:	MOV	(SP)+,-(R3)	;COPY IMAGE OF WINDOW BLOCK INTO REAL BLOCK
	CMP	R3,R4		;DONE YET?
	BHI	60$		;IF HI NO

; IF THIS IS A USER D OR SUPER LIB SYSTEM, THEN THERE IS A FLAG WORD ON
; THE STACK. IF SUPER LIB SYSTEM ONLY, WE CAN DISCARD THIS WORD. IF USER
; D, THEN THE HIGH BYTE OF THIS WORD MUST BE RE-WRITTEN TO H.DMAP IN THE
; TASK HEADER. IN ADDITION, USER D SYSTEMS HAVE AN OVERMAP DEFAULT FLAG
; WHICH MUST BE REMOVED FROM THE STACK.

	.IF NDF	U$$DAS

	.IF DF	S$$LIB

	TST	(SP)+		;CLEAN OFF FLAG WORD

	.ENDC	; DF S$$LIB

	.IFF	; NDF U$$DAS

	
	.IF DF	X$$HDR

	MOV	$SAHPT,R0	;GET ADDRESS OF TASK HEADER

	.IFF

	MOV	$HEADR,R0	;GET ADDRESS OF TASK HEADER
	
	.ENDC


	MOV	(SP)+,H.SMAP(R0) ;UPDATE SUPER/USER D MASK IN HEADER

	.ENDC	; DF U$$DAS

	MOV	$TKTCB,R0	;PICK UP CURRENT TASK TCB ADDRESS
	MOV	W.BPCB(R4),R1	;PICK UP PCB OF MAPPING
	
	
	.IF DF	M$$PRO
	
	CALL	$SETBP		;SET UP OTHER RUNNING MAPPED TASK (IF ANY)
	
	.ENDC
	
	
	TSTB	A.MPCT(R5)	;IS THIS FIRST MAP THROUGH ATTACHMENT ?
	BNE	65$		;IF NE NO, DON'T CALL $ACCRG
	MOV	#$ACCRG,-(SP)	;FORCE RETURN THROUGH $ACCRG
65$:	INCB	A.MPCT(R5)	;INCREMENT MAPPING THROUGH THIS ADB

	.IF DF X$$HDR&F$$MAP

	CALL	$STFMC		;SETUP FAST MAP IF NECESSARY

	.ENDC ; DF X$$HDR&F$$MAP

	RETURN			;BACK TO CALLER (OR $ACCRG)
70$:	DRSTS	D.RS84		;INVALID OFFSET-LENGTH COMBINATION
80$:	DRSTS	D.RS16		;DESIRED ACCESS TO REGION DENIED
90$:	DRSTS	D.RS6		;REGION HAD LOAD FAILURE OR PARITY ERROR
100$:	DRSTS	D.RS8		;REGION IS NON RESIDENT
	.PAGE
;+
; **-$DRUNM-UNMAP ADDRESS WINDOW
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO UNMAP THE SPECIFIED ADDRESS
; WINDOW.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(123.),DPB SIZE(2.)
;	WD. 01 -- ADDRESS OF WINDOW DEFINITION BLOCK
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE WINDOW DEFINITION BLOCK.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
;	INPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NID=ID OF WINDOW TO UNMAP.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS WORD RETURNED TO TASK)
;
;	C=0 IF DIRECTIVE IS SUCCESSFULLY COMPLETED.
;		DIRECTIVE STATUS OF +1 IS RETURNED.
;	C=1 IF DIRECTIVE IS REJECTED.
;		DIRECTIVE STATUS OF 'D.RS8' IS RETURNED IF THE SPECIFIED
;			ADDRESS WINDOW NOT MAPPED.
;		DIRECTIVE STATUS OF 'D.RS87' IS RETURNED IF AN INVALID
;			ADDRESS WINDOW ID IS SPECIFIED.
;
;	OUTPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NSTS=INDICATION OF ANY CHANGES IN MAPPING STATUS.
;			WS.UNM=1 IF THE WINDOW WAS SUCCESSFULLY UNMAPPED.
;-

$DRUNM::CALL	$SRWND		;SEARCH FOR AND VERIFY WINDOW ID
	CALL	$UNMAP		;UNMAP IF NECESSARY
	BCC	10$		;IF CC WINDOW WAS NOT MAPPED
	BIS	#WS.UNM,W.NSTS(R3) ;INDICATE ADDRESS WINDOW WAS UNMAPPED
	RETURN			;
10$:	DRSTS	D.RS8		;ADDRESS WINDOW WAS NOT MAPPED



;+
; DRSRF HAS MOVED.
;
; ITS FORWARDING ADDRESS IS DRSRF.MAC
;
; THIS IS DUE TO THE ADDITION OF A SEPARATE COMMON FOR THE
; PLAS DIRECTIVES.
;
; YOU MAY BE WONDERING WHY DRRRF IS STILL HERE. ALL DIRECTIVES
; WHICH USE A PLAS DEFINITION BLOCK WHICH IS RELOCATED BY DRDSP 
; MUST BE IN THE SAME DIRECTIVE COMMON, SINCE THE RELOCATION OF
; THE RDB/WDB TRIGGERS MAPPING THE PLAS COMMON. DRSRF RELOCATES
; THE BLOCK ITSELF AND THEREFORE CAN'T BE INCLUDED IN THE COMMON.
;-
	.PAGE
;+
; **-$DRRRF-RECEIVE BY REFERENCE
;
; THIS DIRECTIVE INSTRUCTS THE SYSTEM TO DEQUEUE THE NEXT RECEIVE BY
; REFERENCE PACKET IN THE RECEIVE QUEUE, OPTIONALLY EXITING IF THERE IS
; NOT ONE THERE.
;
; DPB FORMAT:
;
;	WD. 00 -- DIC(81.),DPB SIZE(2.)
;	WD. 01 -- ADDRESS OF WINDOW DEFINITION BLOCK
;
; INPUTS:
;
;	R2=ADDRESS OF THE TASK STATUS WORD OF THE CURRENT TASK.
;	R3=ADDRESS OF THE WINDOW DEFINITION BLOCK.
;	R4=ADDRESS OF THE HEADER OF THE CURRENT TASK.
;	R5=ADDRESS OF THE TCB OF THE CURRENT TASK.
;
;	INPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NSTS=CONTROL INFORMATION.
;			WS.MAP=1 IF RECEIVED REFERENCE IS TO BE MAPPED.
;			WS.RCX=1 IF TASK EXIT DESIRED IF NO PACKET FOUND.
;		W.NSRB=OPTIONAL ADDRESS OF 10 WORD BUFFER FOR ADDITIONAL INFO.
;
; OUTPUTS: (DIRECTIVE STATUS AND PS RETURNED TO TASK)
;
;	C=0 IF DIRECTIVE IS SUCCESSFULLY COMPLETED.
;		DIRECTIVE STATUS OF +1 IS RETURNED.
;	C=1 IF DIRECTIVE IS REJECTED.
;		DIRECTIVE STATUS OF 'D.RS6' IS RETURNED IF THE
;			DIRECTIVE FAILS IN THE MAPPING STAGE BECAUSE
;			THE SPECIFIED REGION HAS INCURRED A PARITY
;			ERROR.
;		DIRECTIVE STATUS OF 'D.RS8' IS RETURNED IF THERE IS NO
;			RECEIVE BY REFERENCE ENTRY IN THE QUEUE.
;		DIRECTIVE STATUS OF 'D.RS98' IS RETURNED IF THE ADDRESS
;			CHECK OF THE RECEIVE BUFFER FAILS.
;
;	OUTPUT FIELDS IN THE WINDOW DEFINITION BLOCK ARE:
;		W.NRID=ASSIGNED REGION ID OF THE REFERENCED REGION.
;		W.NOFF=OFFSET WORD SPECIFIED BY SENDER TASK.
;		W.NLEN=LENGTH WORD SPECIFIED BY SENDER TASK.
;		W.NSTS=STATUS WORD SPECIFIED BY SENDER TASK.
;			WS.RED=1 IF ATTACHED WITH READ ACCESS.
;			WS.WRT=1 IF ATTACHED WITH WRITE ACCESS.
;			WS.EXT=1 IF ATTACHED WITH EXTEND ACCESS.
;			WS.DEL=1 IF ATTACHED WITH DELETE ACCESS.
;			WS.RRF=1 IF RECEIVE WAS SUCCESSFUL.
;-

$DRRRF::MOV	KISAR6,-(SP)	;SAVE APR6 BIAS
	MOV	R3,-(SP)	;SAVE WINDOW DEFINITION BLOCK POINTER
	MOV	T.RRFL(R5),R2	;PICK UP FIRST RECEIVE BY REF PACKET
	BEQ	60$		;IF EQ THERE IS NONE
	CLR	-(SP)		;INIT EFN ADDRESS
	CLR	-(SP)		;INIT EFN MASK
	TST	(R2)+		;POINT TO RECEIVER TCB ADDRESS IN PACKET
	MOV	(R2)+,R0	;PICK UP TCB ADDRESS
	BEQ	20$		;IF EQ NONE SPECIFIED
	DECB	T.SRCT(R0)	;DECREMENT SENDER'S OUTSTANDING SREFS
	MOV	(R2),(SP)	;SET REAL EFN MASK			
	MOV	2(R2),2(SP)	;SET REAL EFN ADDRESS
20$:	MOV	R0,-(SP)	;SAVE TCB ADDRESS			
	CMP	(R2)+,(R2)+	;SKIP TO REGION ID			
	ADD	#W.NRID,R3	;POINT TO REGION ID WORD IN DEF BLOCK	
	MOV	(R2)+,(R3)+	;STORE REGION ID
	MOV	(R2)+,(R3)+	;STORE OFFSET
	MOV	(R2)+,(R3)+	;STORE LENGTH
	BIS	(R2)+,(R3)+	;STORE ACCESS
	MOV	(R3),R3		;PICK UP VIRTUAL ADDR OF EXTENDED INFO BUFFER
	BEQ	40$		;IF EQ THERE ONE WAS NOT SPECIFIED
	MOV	#10.*2,R1	;SET SIZE TO ADDRESS CHECK
	MOV	R2,-(SP)	;SAVE R2
	CALL	$ACHKP		;ADDRESS CHECK THE BUFFER
	MOV	(SP)+,R2	;RESTORE R2
	MOV	-14(R2),(R3)+	;STORE THE TASK NAME IN THE BUFFER
	MOV	-12(R2),(R3)+	;
	MOV	-16(R2),R0	;PICK UP SENDER TCB ADDRESS
	BEQ	25$		;IF EQ THERE IS NONE
	MOV	T.NAM+2(R0),-(R3) ;SET REAL TASK NAME
	MOV	T.NAM(R0),-(R3)	;
	CMP	(R3)+,(R3)+	;POINT PAST TASK NAME
25$:	MOV	#8.,R0		;SET LOOP COUNT FOR REST OF INFO
30$:	MOV	(R2)+,(R3)+	;MOVE REST OF EXTRA INFO
	DEC	R0		;DONE YET?
	BGT	30$		;IF GT NO
40$:	MOV	R5,R3		;SAVE RECEIVER TASK TCB ADDRESS		
	MOV	(SP)+,R5	;RETRIEVE SENDER TASK TCB ADDRESS	
	MOV	(SP)+,R0	;RETRIEVE EVENT FLAG MASK		
	MOV	(SP)+,R1	;RETRIEVE EVENT FLAG WORD ADDRESS	
	BEQ	50$		;IF EQ NO FLAG TO SET			
	CALL	$SETMG		;SET EFN AND UNLOCK IF GROUP GLOBAL
50$:	MOV	R3,R5		;RESTORE TCB ADDRESS			
	MOV	R5,R0		;POINT TO RECEIVE BY REFERENCE LISTHEAD	
	ADD	#T.RRFL,R0	;					
	CALL	$QRMVF		;REMOVE PROCESSED PACKET
	MOV	R1,R0		;COPY POINTER TO PACKET
	CALL	$DEPKT		;DEALLOCATE PACKET
	MOV	(SP)+,R3	;RESTORE WINDOW DEFINITION POINTER
	MOV	(SP)+,KISAR6	;RESTORE KERNAL APR6 BIAS
	BIS	#WS.RRF,W.NSTS(R3) ;INDICATE SUCCESSFUL RECEIVE BY REFERENCE
	BIT	#WS.MAP,W.NSTS(R3) ;WINDOW MAP DESIRED?
	BEQ	80$		;IF EQ NO
	CALLR	$DRMAP		;MAP WINDOW
60$:	CMPB	#213.,$DICSV 	;IS THIS RECEIVE BY REFERENCE OR STOP?
	BNE	61$		;IF NE NO
	CMP	(SP)+,(SP)+	;CLEAN STACK
	JMP	$STPCT		;GO STOP TASK
61$:	BIT	#WS.RCX,W.NSTS(R3) ;DOES TASK WISH TO EXIT?
	BEQ	70$		;IF EQ NO
	CMP	(SP)+,(SP)+	;CLEAN STACK
	JMP	$DREXT		;PERFORM TASK EXIT
70$:	DRSTS	D.RS8		;NO REFERENCES IN QUEUE
80$:	RETURN			;
	.PAGE
;+
; **-$DRFMP-FAST REMAP OF TASK ADDRESS WINDOW
;
; THIS DIRECTIVE IS INVOKED TO PERFORM A FAST REMAP OF A TASK
; ADDRESS WINDOW. THIS IS NOT A DIRECTIVE PER SE (REQUIRES NO
; DPB), BUT IS INVOKED BY LOADING USER REGISTERS AND EXECUTING
; AN IOT INSTRUCTION.
;
; TASKS BUILT TO MAKE USE OF THE FAST MAP FACILITY HAVE AN
; ADDITIONAL DATA AREA APPENDED TO THEIR HEADERS. THE FORMAT
; OF THIS BLOCK IS DOCUMENTED IN $STFMP BELOW.
;
; INPUTS:
;
;	R0 = FAST MAP ID
;	R1 = NEW MAP OFFSET
;
; OUTPUTS:
;
;	R0 = COMPLETION STATUS
;		    +1 = SUCCESS
;		IE.ALG = INVALID OFFSET
;
; NOTES:
;
; R0 -> R3 ARE DESTROYED DURING FAST MAP PROCESSING.
;
; FAST MAP TAKES PLACE AT PR7, KERNEL MODE, STACK DEPTH +1.
;
; FAST MAP WITH WINDOW LENGTH CHANGE TAKES PLACE AT PR0, KERNEL MODE,
; STACK DEPTH 0 (LOOKS LIKE INTERRUPT STATE FOR A PR0 DEVICE).
;
; ALTHOUGH SUPERVISOR MODE WINDOWS CAN'T YET BE FAST MAPPED, THE COMMENTS
; IN THIS MODULE INCLUDE INFORMATION RELATIVE TO THAT IMPLEMENTATION.
;
; BLKMUL IS SET TO 2 IF SYSTEM HAS BOTH USER D AND SUPER MODE SUPPORT,
; 1 OTHERWISE. THIS IS BECAUSE THE OFFSET INTO JUMP TABLE FIELD MUST
; BE BIGGER THAN 255. IF THE SYSTEM HAS BOTH.
;-

	.IF DF X$$HDR&F$$MAP

	.IF DF U$$DAS&S$$LIB

	BLKMUL = 1
	BLKDIV = 2

	.IFF ; DF U$$DAS & S$$LIB

	BLKMUL = 2
	BLKDIV = 1

	.ENDC ; DF U$$DAS & S$$LIB


;+

$DRFMP::NOP			;;;* * * DEBUG * * *
	MOV	$SAHDB,KISAR6	;;;MAP CURRENT USER TASK HEADER
	BIC	#77607,R0	;;;VALIDATE USER'S FAST MAP POINTER
				;;;(FORCE POINTER TO BE VALID)
				;;;(ALSO, TEST HIGH BIT TO SEE IF WINDOW 
				;;;LENGTH CHANGE WAS DESIRED.)
	BMI	20$		;;;IF MI LENGTH CHANGE DESIRED
	ADD 	$FMAPP,R0	;;;GET POINTER TO FAST MAP AREA

	CMP	R1,(R0)+	;;;PAST MAXIMUM OFFSET?
	BHIS	10$		;;;IF HI YES

	MOV	(R0)+,R2	;;;GET ADDRESS OF W.BOFF
	MOV	R1,(R2)		;;;STORE NEW OFFSET FIELD (LESS P.HDLN)

	ADD	@(R0)+,R1	;;;ADD IN P.REL OF PCB TO OFFSET

	MOVB	(R0)+,R3	;;;GET P.HDLN VALUE AND EXPAND TO WORD
	ADD	R3,R1		;;;FORM REAL ADDRESS OF MAPPED AREA
	ADD	R3,(R2)+	;;;ADJUST OFFSET IN WINDOW BLOCK

	MOVB	(R2)+,R2	;;;GET APR ADDRESS
	ADD	#UISAR0-UISDR0,R2 ;;;POINT TO PAR INSTEAD OF PAR

	MOVB	(R0),R0		;;;GET JUMP TABLE VALUE

	.IF DF U$$DAS & S$$LIB

	ASL	R0		;;;SHIFT INDEX TO WORDS

	.ENDC ; DF U$$DAS & S$$LIB

	MOV	#200,R3		;;;SET OFFSET BETWEEN PARS
	CALL	FMPW1(R0)	;;;AND DISPATCH INTO IT

	MOV	#1,R0		;;;SET SUCCESS STATUS
	RTT			;;;AND RETURN

10$:	MOV	#D.RS8,R0	;;;INDICATE IE.ITS
	RTT			;;;RETURN TO USER TASK

; ERROR EXITS FOR LENGTH CHANGE

11$:	MOV	#D.RS8,R0	;;;INDICATE IE.ITS
	JMP	$INTX1		;;;RETURN TO USER TASK

12$:	MOV	#D.RS84,R0	;;;INDICATE IE.ALG
	JMP	$INTX1		;;;RETURN TO USER TASK

	.PAGE
;+
; FAST MAP WITH CHANGE IN LENGTH
;-

20$:				;;;REFERENCE LABEL

; SAVE SOME REGISTERS AND DROP PROCESSOR PRIORITY

	MOV	R5,-(SP)	;;;SAVE R5
	MOV	R4,-(SP)	;;;AND R4
	DEC	$STKDP		;;;SHOW ENTRY TO SYSTEM
	MTPS	#0		;;;ALLOW INTERRUPTS
	NOP			;;; * * *   D E B U G   * * *

; CALCULATE ADDRESS OF FAST MAP HEADER BLOCK AND SET UP
; REGISTERS.

	ADD	#100002,R0	;REMOVE LENGTH CHANGE INDICATOR
				;AND SKIP MAX OFFSET FIELD
	ADD	$FMAPP,R0	;SET UP POINTER TO FAST MAP BLOCK
	MOV	(R0)+,R4	;R4 -> W.BOFF IN WINDOW BLOCK
	BEQ	11$		;IF EQ, WINDOW NOT MAPPED
	MOV	(R0)+,R5	;R5 -> P.REL IN PCB
	MOVB	(R0)+,R3	;GET P.HDLN FOR PARTITION AND
				;SIGN EXTEND
	ADD	R3,R1		;ADJUST OFFSET FIELD BY P.HDLN

; CALCULATE LENGTH TO MAP AND TEST IF LEGAL. IF NOT, RETURN IE.ITS

	TST	R2		     ;LENGTH SPECIFIED
	BEQ	30$		     ;IF EQ NO, CALCULATE LENGTH
	MOV	R2,R3		     ;COPY LENGTH
	ADD	R1,R3		     ;ADD IN OFFSET
	BCS	11$		     ;IF CS ADD WRAPPED AROUND
	CMP	R3,P.SIZE-P.REL(R5)  ;LENGTH LEGAL?
	BLOS	40$		     ;IF LOS YES
	BR	11$		     ;IF HI NO

30$:	MOV	P.SIZE-P.REL(R5),R2  ;GET PARTITION SIZE
	SUB	R1,R2		     ;SUBTRACT OFFSET TO CALC. LENGTH
	BCS	11$		     ;IF CS SUBTRACT WRAPPED AROUND
	CMP	R2,W.BSIZ-W.BOFF(R4) ;LENGTH LEGAL?
	BLOS	40$		     ;IF LOS YES
	MOV	W.BSIZ-W.BOFF(R4),R2 ;SUBSTITUTE WINDOW SIZE

; CALCULATE NEW END VIRTUAL ADDRESS

40$:	MOV	R1,(R4)		     ;SET NEW W.BOFF FIELD VALUE
	ADD	(R5),R1		     ;CONVERT OFFSET TO PHYSICAL ADDRESS
	MOV	R0,R5		     ;SAVE POINTER TO OFFSET VALUE
	MOV	R2,R3		     ;COPY LENGTH IN 32 WD BLOCKS
	ASH	#6,R3		     ;CONVERT TO BYTES
	DEC	R3		     ;BACK OFF TO LAST BYTE ADDRESS
	ADD	W.BLVR-W.BOFF(R4),R3 ;ADD IN LOW VIRTUAL ADDRESS

; SAVE VALUES NEEDED IN PAR UPDATE CODE OR RETURNED TO USER

	MOV	R2,-(SP)	     ;SAVE NEW LENGTH OF WINDOW
	MOV	R1,-(SP)	     ;SAVE PHYSICAL MAP ADDRESS
	CMP	R3,W.BHVR-W.BOFF(R4) ;SIZE OF WINDOW CHANGE AT ALL?
	BEQ	100$		     ;IF EQ NO
	MOV	R3,W.BHVR-W.BOFF(R4) ;TO FORM HIGH VIRTUAL ADDRESS

; CALCULATE NEW NUMBER OF PDRS

	MOV	R2,R3		     ;COPY SIZE OF WINDOW
	ADD	#177,R3		     ;ROUND UP BY 4K
	ASH	#-7,R3		     ;CONVERT TO NUMBER OF PDRS
	MOV	R3,-(SP)	     ;SAVE FOR LAST PDR ADDRESS
				     ;CALCULATION LATER
	CMPB	R3,W.BNPD-W.BOFF(R4) ;NUMBER OF PDRS CHANGE ?
	BEQ	80$		     ;IF EQ NO, NO NEED TO UPDATE
				     ;OFFSET OR CLEAR/RESET PDRS
	MOVB	W.BNPD-W.BOFF(R4),R2 ;GET OLD NUMBER OF PDRS
	MOVB	R3,W.BNPD-W.BOFF(R4) ;SET NEW NUMBER OFR PDRS

; CALCULATE NEW OFFSET FIELD FOR FAST MAP WINDOW BLOCK

	SUB	R2,R3		     ;FORM DIFFERENCE IN NUMBER OF PDRS

; HANDLE SIMPLEST CASES (1,3,4,7)

	.IF DF U$$DAS!S$$LIB

	CMPB	#<<FMPW2-FMPW1>/BLKDIV>,(R0) ;IS THIS A CASE 1
	BHI	50$		     ;IF HI YES

	.IFTF	; DF U$$DAS ! S$$LIB

	ASL	R3		     ;MULTIPLY DIFFERENCE BY 2

	.IF EQ	BLKMUL-2

	ASL	R3		     ;BY 4

	.ENDC	; EQ BLKMUL-2

	.IFT	; DF U$$DAS ! S$$LIB

	BR	70$		     ;AND UPDATE
50$:

;	HANDLE CASE 2 (ALSO HANDLES CASE 6) IN I/D & SUPER SYSTEMS

	.IF DF U$$DAS&S$$LIB

	CMPB	#<<FMPW5-FMPW1>/BLKDIV>,(R0) ;IS THIS A CASE 2
	BHI	60$		     ;IF HI NO
	MUL	#<BLK2SZ*BLKMUL>,R3  ;CALCULATE DIFFERENCE
	BR	70$		     ;AND UPDATE

	.ENDC	; DF U$$DAS&S$$LIB

60$:

; HANDLE CASE 5 (ALSO CASE 2 IN SUPER, NO D-SPACE SYSTEMS)

	MUL	#<BLK5SZ*BLKMUL>,R3  ;CALCULATE DIFFERENCE

	.ENDC	; DF U$$DAS ! S$$LIB

70$:

	MOV	R3,-(SP)	     ;SAVE FOR UPDATE

; CLEAR ALL PDRS FOR OLD WINDOW

	CLR	R3		     ;NO OFFSET BETWEEN PDRS
	MOVB	W.BFPD-W.BOFF(R4),R2 ;POINT TO PDR
	MOV	(R2),-(SP)	     ;SAVE A PDR FOR ACCESS VALUE
	CLR	R1		     ;VALUE TO STORE IS ZERO
	MOVB	(R0),R0		     ;GET OFFSET VALUE

	.IF DF U$$DAS&S$$LIB

	ASL	R0		     ;CONVERT TO BYTE INDEX

	.ENDC ; DF U$$DAS&S$$LIB

	CALL	FMPW1(R0)	     ;CLEAR PDRS

; SET ALL PDRS FOR NEW WINDOW

	.IF DF U$$DAS&S$$LIB

	MOVB	(R5),R0		     ;RETRIEVE OFFSET FIELD AGAIN

	.IFTF	; DF U$$DAS & S$$LIB

	MOV	(SP)+,R1	     ;GET PDR VALUE
	SUB	(SP)+,R0	     ;ADJUST OFFSET FIELD
	BIS	#77400,R1	     ;FORCE 4K ACCESS
	MOVB	R0,(R5)		     ;STORE UPDATED OFFSET VALUE
	MOVB	W.BFPD-W.BOFF(R4),R2 ;GET PDR ADDRESS (AGAIN)

	.IFT  ; DF U$$DAS & S$$LIB

	ASL	R0		     ;ADJUST TO WORD VALUE

	.ENDC ; DF U$$DAS & S$$LIB

	CALL	FMPW1(R0)	     ;SET PDRS TO NEW VALUE

; SETUP LAST PDR TO CORRECT VALUE

80$:	MOV	4(SP),R2	     ;RETRIEVE WINDOW SIZE
	DEC	R2		     ;BACK OFF TO LAST BLOCK
	BIC	#177600,R2	     ;ISOLATE PLF BITS
	SWAB	R2		     ;PUT IN RIGHT PLACE IN REGISTER
	MOVB	W.BFPD-W.BOFF(R4),R3 ;GET FIRST PDR ADDRESS
	MOV	(R3),R1		     ;FETCH VALUE OF A PDR
	BIC	#77400,R1	     ;CLEAR PLF FROM SAVED PDR
	BIS	R2,R1		     ;AND MERGE NEW PLF
	DEC	(SP)		     ;BACK OFF BY ONE PDR
	ASL	(SP)		     ;MULTIPLY NUMBER OF PDRS BY 2
	ADD	(SP)+,R3	     ;FORM LAST PDR ADDRESS

	.IF DF S$$LIB!U$$DAS

	CMPB	#<<FMPW2-FMPW1>/BLKDIV>,(R5) ;IS THIS A CASE 1
	BLOS	90$		     ;IF HI YES

; UPDATE LAST PDR FOR A CASE 2 WINDOW

	.IF DF U$$DAS

	CMPB	#<<FMPW6-FMPW1>/BLKDIV>,(R5) ;IS THIS A CASE 2
	BHI	84$		     ;IF HI NO
	MOV	R1,UDSAR0-UINAR0(R3) ;;;FILL IN LAST PDR (D)
	BR	90$		     ;AND CONTINUE

; UPDATE LAST PDR FOR CASE 6 WINDOW

84$:
	CMPB	#<<FMPW5-FMPW1>/BLKDIV>,(R5) ;IS THIS A CASE 6
		BHI	86$		     ;IF HI NO
	MOV	R1,SDSAR0-UDSAR0(R3) ;;;FILL IN LAST PDR (D)
	BR	100$		     ;AND UPDATE
86$:
	.ENDC	; DF U$$DAS

; UPDATE LAST PDR FOR CASE 5 WINDOW

	MOV	R1,SDSAR0-UINAR0(R3) ;;;FILL IN LAST PDR (SUPER D)

	.IF DF U$$DAS

	MOV	R1,UDSAR0-UINAR0(R3) ;;;FILL IN LAST PDR (USER D)

	.ENDC ; DF U$$DAS

	.ENDC	; DF U$$DAS ! S$$LIB

90$:	MOV	R1,(R3)		     ;FILL IN LAST PDR
	MOV	R1,W.BLPD-W.BOFF(R4) ;SAVE VALUE OF LAST PDR IN WINDOW BLOCK

; DISPATCH TO REGULAR PAR UPDATE CODE

100$:	MOV	#200,R3		     ;SET OFFSET BETWEEN PARS TO 4K
	MOVB	W.BFPD-W.BOFF(R4),R2 ;GET FIRST PDR ADDRESS AGAIN.
	ADD	#UINAR0-UINDR0,R2    ;POINT TO PAR INSTEAD OF PDR
	MOV	(SP)+,R1	     ;GET BACK VALUE OF START (THIS RIGHT?)
	MOVB	(R5),R0		     ;GET OFFSET VALUE AGAIN

	.IF DF U$$DAS&S$$LIB

	ASL	R0		     ;ADJUST TO BYTE INDEX

	.ENDC ; DF U$$DAS & S$$LIB
	
	CALL	FMPW1(R0)	     ;GO ADJUST PARS
	MOV	(SP)+,R2	     ;SET LENGTH TO RETURN TO USER
	MOV	#1,R0		     ;SET IS.SUC FOR RETURN
	JMP	$INTX1		     ;GO RETURN TO USER

	.ENDC	; DF X$$HDR & F$$MAP
	.PAGE

;+
; **-$STFMP-SETUP FAST MAP BLOCK FOR ADDRESS WINDOW
; **-$STFMC-SETUP FAST MAP BLOCK FOR ADDRESS WINDOW (CONDITIONALLY)
;
; THESE ROUTINES SETS OR RE-SETS THE FAST MAP BLOCK IN THE HEADER
; EXTENSION CORRESPONDING TO A WINDOW IN THE NORMAL HEADER AREA.
;
; $STFMC IS CALLED FROM DRMAP TO EXAMINE WHETHER OR NOT A WINDOW
; REQUIRES FAST MAP UPDATE AND TO RE-FILL THE POINTERS IF NECESSARY.
;
; INPUTS:
;
;	R4=ADDRESS OF WINDOW TO BE FAST MAPPED
;
; OUTPUTS:
;
;	R2,R3 ARE MODIFIED ($STFMC)
;	R0,R2,R3 ARE MODIFIE ($STFMP)
;
; THE FORMAT OF A FAST MAP HEADER EXTENSION BLOCK IS AS FOLLOWS:
;
;	+-----------------------------------------------+
;	| MAXIMUM 32WD BLOCK OFFSET			| 0
;	+-----------------------------------------------+
;	| POINTER TO W.BOFF IN WINDOW BLOCK		| 2
;	+-----------------------------------------------+
;	| POINTER TO P.REL IN PCB			| 4
;	+-----------------------+-----------------------+
;     7	| DISPATCH OFFSET INTO  | COPY OF P.HDLN FOR	| 6
;	| FMPW1 UPDATE VECTOR   | TARGET PARTITION	|
;	+-----------------------------------------------+
;-

	.IF DF X$$HDR&F$$MAP

	.ENABL	LSB

$STFMC::TST	$FMAPP		;TASK HAVE FAST MAP ENABLED?
	BEQ	10$		;IF EQ NO, NO UPDATE
	TSTB	W.BFPD(R4)	;IS IT A USER MODE WINDOW?
	BPL	10$		;IF PL NO, NO UPDATE
	MOV	R0,-(SP)	;SAVE A REGISTER
	MOVB	W.BFPD(R4),R0	;GET ADDRESS OF FIRST PDR
	ASL	R0		;CONVERT TO QUAD WORD
	ASL	R0		;INDEX
	BIC	#177607,R0	;GET RID OF ALL BUT INDEX
	ADD	$FMAPP,R0	;GET ADDRESS OF FAST MAP AREA
	CALL	20$		;GO ADJUST FAST MAP PARAMETERS
5$:	MOV	(SP)+,R0	;RESTORE REGISTER
10$:	RETURN

$STFMP::			;

; CALCULATE ADDRESS OF FAST MAP WINDOW

	MOVB	W.BFPD(R4),R0	;GET ADDRESS OF FIRST PDR
	ASL	R0		;CONVERT TO QUAD WORD
	ASL	R0		;INDEX
	BIC	#177607,R0	;GET RID OF ALL BUT INDEX
	ADD	$FMAPP,R0	;GET ADDRESS OF FAST MAP AREA

; CALCULATE MAXIMUM OFFSET INTO REGION

	ASSUME	W.BPCB,0	;W.BPCB MUST BE FIRST WORD OF WINDOW
20$:	MOV	(R4),R2		;GET PCB ADDRESS
	MOV	P.SIZE(R2),(R0)	;SAVE SIZE OF PARTITION
	SUB	W.BSIZ(R4),(R0)	;MAX OFFSET IS LESS WINDOW SIZE
	MOVB	P.HDLN(R2),R3	;CONVERT HEADER LENGTH TO WORD
	SUB	R3,(R0)		;MAX OFFSET IS ALSO WITHOUT HDR LEN
	INC	(R0)+		;THE MAX OFF FIELD IS KEPT +1 SO THAT
				;A VAL. OF ZERO CAN MEAN "UNMAPPED"

; SET UP POINTER TO W.BOFF IN WINDOW BLOCK

	MOV	R4,(R0)		;INIT POINTER TO W.BOFF
	ADD	#W.BOFF,(R0)+	;AND POINT TO CORRECT WORD IN BLOCK

; SET UP POINTER TO P.REL IN PCB

	MOV	R2,(R0)		;SET ADDRESS OF PCB INTO BLOCK
	ADD	#P.REL,(R0)+	;AND POINT TO P.REL

; COPY PARTITIONS EXTERNAL HEADER SIZE

	MOVB	P.HDLN(R2),(R0)+ ;SET SIZE OF PARTITION'S EXT. HDR.
	.PAGE
;+
; NOW CALCULATE OFFSET INTO APR UPDATE TABLE.
; THERE ARE SEVEN CASES TO BE CONSIDERED.
;
;			SUPER MODE MAPPED	SUPER MODE NOT MAPPED
;
; I-SPACE WINDOW	(1) UPDATE I ONLY	(4) UPDATE SUPER I ONLY
; (WITH OVERLAPPING
;  D-SPACE WINDOW(S))
;
; I-SPACE WINDOW	(2) UPDATE I+D		(5) UPDATE I,D, SUPER D
; (NO OVERLAP)
;
; D-SPACE WINDOW	(3) UPDATE D-ONLY	(6) UPDATE D, SUPER D
;
; SUPER I WINDOW	     N/A		(7) SUPER I ONLY
;
; SYSTEMS WITH USER I/D AND NO SUPERVISOR MODE HAVE CASES
; (1), (2), AND (3) ONLY.
;
; SYSTEMS WITH NO USER I/D BUT SUPER MODE HAVE CASE (1) AND A
; SUBSET OF CASE 5.
;-

; IN MULTI-CASE SYSTEMS, ASSUME IT'S THE SIMPLE CASE

	.IF DF U$$DAS!S$$LIB

	CLR	-(SP)		;ASSUME NO EXTRA OFFSET INTO VECTOR
	MOV	#BLK1SZ*BLKMUL,-(SP) ;ASSUME CASE 1 LENGTH

	.ENDC ; DF U$$DAS!S$$LIB

; CHECK FOR SUPERVISOR I-SPACE WINDOW

	.IF DF S$$LIB

;	TSTB	W.BFPD(R4)	;IS IT A SUPER I-SPACE WINDOW?
;	BEQ	50$		;IF EQ YES

	.ENDC ; DF S$$LIB

; CHECK FOR USER D-SPACE WINDOW

	.IF DF U$$DAS

	BITB	#20,W.BFPD(R4)	;IS IT A USER D-SPACE WINDOW
	BEQ	30$		;IF EQ NO

; IF USER D-SPACE WINDOW, CHECK FOR SUPERVISOR MODE WINDOWS

	.IF DF S$$LIB

	TSTB	$SUPFL		;ANY SUPERVISOR MODE WINDOWS
	BEQ	50$		;IF EQ NO
	MOV	#<<FMPW1-FMPW6>/BLKDIV>,2(SP) ;SET PARAMETERS FOR CASE 6
	MOV	#BLK6SZ*BLKMUL,(SP)      ;

	.ENDC	; DF S$$LIB

	BR	50$		;TO COMMON CODE

	.ENDC ; DF U$$DAS

; CHECK USER I WINDOW FOR OVERLAPPING D-SPACE WINDOWS

30$:				;

	.IF DF	U$$DAS

	MOVB	W.BFPD(R4),R3	;GET PDR ADDRESS
	SUB	#UINDR0,R3	;ADJUST TO OFFSET ZERO
	ASR	R3		;CONVERT TO BYTE INDEX
	MOVB	W.BNPD(R4),R2	;GET NUMBER OF PDRS
	ADD	R3,R2		;FORM ENDING PDR NUMBER +1
	MOVB	$BCMSK-1(R2),R2 ;GET MASK UP TO LAST APR
	BICB	$BCMSK-1(R3),R2 ;GET MASK UP TO FIRST APR
	MOV	$SAHPT,R3	;POINT TO HEADER
	BITB	R2,H.DMAP(R3)	;ANY OVERLAP?
	BNE	50$		;IF NE YES, UPDATE I ONLY

	.ENDC	; DF U$$DAS

; USER I-SPACE WITH NO OVERLAP D WINDOWS

	.IF DF S$$LIB

	TSTB	$SUPFL		;SUPER MODE WINDOWS?
	BEQ	40$		;IF EQ NO

	MOV	#<<FMPW1-FMPW5>/BLKDIV>,2(SP) ;SET PARAMETERS FOR CASE 5
	MOV	#BLK5SZ*BLKMUL,(SP)      ;
	BR	50$		;TO COMMON CODE 

	.ENDC ; DF S$$LIB
40$:
	.IF DF	U$$DAS

	MOV	#<<FMPW1-FMPW2>/BLKDIV>,2(SP)	;SET PARAMETERS FOR CASE 6
	MOV	#BLK2SZ*BLKMUL,(SP)      ;
	
	.ENDC ; DF U$$DAS

50$:	MOVB	W.BNPD(R4),R3	;FETCH NUMBER OF PDRS

	.IF DF U$$DAS!S$$LIB

	MUL	(SP)+,R3	;CONVERT TO N WORD INDEX
	ADD	(SP)+,R3	;ADD IN ANY ADDITIONAL OFFSET

	.IFF ; DF U$$DAS!S$$LIB

	ASL 	R3		;CONVERT TO WORD INDEX
	ASL 	R3		;CONVERT TO TWO WORD INDEX

	.ENDC	; DF U$$DAS!S$$LIB

	NEG	R3		;MAKE IT NEGATIVE
	MOVB	R3,(R0)+	;SET JUMP INDEX
	RETURN			;DONE

	.DSABL	LSB

	.ENDC ; DF X$$HDR&F$$MAP

	.PAGE

;+
; FAST MAP APR UPDATE TABLES. THERE ARE FOUR SETS OF UPDATE CODE TO
; COVER THE SEVEN CASES.
;-

	.IF DF F$$MAP&X$$HDR

;+
; CASE 5 - UPDATE SUPER AND USER DATA SPACE AND PAR POINTED TO BY FAST 
;	   MAP WINDOW BLOCK (THIS WILL ALWAYS BE USER I-SPACE)
;-

	.IF DF S$$LIB

	.REPT 7

	MOV	R1,SDSAR0-UINAR0(R2) ;;;FILL IN SUPER D PAR/PDR

	.IF DF U$$DAS

	MOV	R1,UDSAR0-UINAR0(R2) ;;;FILL IN USER D PAR/PDR

	.ENDC ; DF U$$DAS

	MOV	R1,(R2)+	     ;;;FILL IN USER I PAR/PDR
	ADD	R3,R1		     ;;;AND ADVANCE BY 4KW

	.ENDR

	.IF DF U$$DAS

	BLK5SZ = 6

	.IFF ; DF U$$DAS

	BLK5SZ = 4

	.ENDC ; DF U$$DAS

	$$$ = .
	. = . + < BLK5SZ * 2 >
FMPW5:				     ;;;POINT TO END OF BLOCKS
	. = $$$

	MOV	R1,SDSAR0-UINAR0(R2) ;;;FILL IN LAST SUPER D PAR/PDR

	.IF DF U$$DAS

	MOV	R1,UDSAR0-UINAR0(R2) ;;;FILL IN LAST USER D PAR/PDR

	.ENDC ; DF U$$DAS

	MOV	R1,(R2)		     ;;;FILL IN LAST USER I PAR/PDR
	RETURN 			     ;;;AND GO BACK

	.ENDC ; DF S$$LIB


;+
; CASE 6 - UPDATE SUPER DATA SPACE AND PAR POINTED TO BY FAST MAP WINDOW
;	   BLOCK (THIS WILL ALWAYS BE USER D-SPACE)
;-

	.IF DF U$$DAS&S$$LIB

	.REPT 7

	MOV	R1,SDSAR0-UDSAR0(R2) ;;;FILL IN SUPER D PAR/PDR
	MOV	R1,(R2)+	     ;;;FILL IN USER D PAR/PDR
	ADD	R3,R1		     ;;;AND ADVANCE BY 4KW

	.ENDR

	BLK6SZ = 4

	$$$ = .
	. = . + < BLK6SZ * 2 >
FMPW6:				     ;;;POINT TO END OF BLOCKS
	. = $$$

	MOV	R1,SDSAR0-UDSAR0(R2) ;;;FILL IN LAST SUPER D PAR/PDR
	MOV	R1,(R2)		     ;;;FILL IN LAST USER U PAR/PDR
	RETURN			     ;;;AND GO BACK

	.ENDC ; DF U$$DAS & S$$LIB

;+
; CASE 2 - UPDATE USER DATA SPACE AND PAR POINTED TO BY FAST MAP WINDOW
;	   BLOCK (THIS WILL ALWAYS BE USER I SPACE)
;-

	.IF DF U$$DAS

	.REPT 7

	MOV	R1,UDSAR0-UINAR0(R2) ;;;FILL IN USER D PAR/PDR
	MOV	R1,(R2)+	     ;;;FILL IN USER I PAR/PDR
	ADD	R3,R1		     ;;;AND ADVANCE BY 4KW

	.ENDR

	BLK2SZ = 4

	$$$ = .
	. = . + < BLK2SZ * 2 >
FMPW2:				     ;;;POINT TO END OF BLOCKS
	. = $$$

	MOV	R1,UDSAR0-UINAR0(R2) ;;;FILL IN LAST USER D PAR/PDR
	MOV	R1,(R2)		     ;;;FILL IN LAST USER I PAR/PDR
	RETURN 			     ;;;AND GO BACK

	.IFF ; DF U$$DAS

FMPW2:				     ;;;MAKE SURE THIS LABEL IS ALWAYS
				     ;;;DEFINED SO THAT THE OFFSET
				     ;;;ADJUST CODE CAN COMPARE AGAINST IT.

	.ENDC ; DF U$$DAS

;+
; CASES 1, 3, 4, AND 7. UPDATE JUST THE APR POINTED TO BY
; THE FAST MAP WINDOW.
;-

	.REPT 7

	MOV	R1,(R2)+	     ;;;FILL IN PAR/PDR
	ADD	R3,R1		     ;;;AND ADVANCE BY 4KW

	.ENDR

	BLK1SZ = 2

	$$$ = .
	. = . + < BLK1SZ * 2 >
FMPW1:				     ;;;POINT TO END OF BLOCKS
	. = $$$
	
	MOV	R1,(R2)		     ;;;FILL IN LAST PAR/PDR
	RETURN 			     ;;;AND GO BACK

	.ENDC ; DF F$$MAP & X$$HDR

									
	.ENDC


	.END